package com.newsmanagement.util;

import com.newsmanagement.common.Constants;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class CheckAndChangeUtil {

    public static String main(String[] args) {
        String str = "   ";
        System.out.println(str.isEmpty());

        return "";
    }


    /**
     * 验证字符串是否 不为空而且内容不光是空格
     * @param verifiedData 被验证的字符串
     * @return
     */
    public static boolean checkStringHaveData(String verifiedData){
        if (!verifiedData.isEmpty() && verifiedData.trim().length() > Constants.INT_ZERO){//不为空，而且去掉数据两边的空格还有数据
            return true;
        }
        return false;
    }

    /**
     * 验证字符串是否 不为空而且内容不光是空格
     * @param verifiedData 被验证的字符串
     * @return
     */
    public static boolean checkStrNoNull(String verifiedData){
        if (null != verifiedData && verifiedData.trim().length() > Constants.INT_ZERO){//不为空，而且去掉数据两边的空格还有数据
            return true;
        }
        return false;
    }


    /**
     * 验证字符串数组中是否全是数字
     * @param verifiedData 被验证的字符串
     * @return
     */
    public static boolean checkStringArrayIsDigital(String[] verifiedData){

        //无数据返回false
        if (null == verifiedData || verifiedData.length < 1){
            return false;
        }

        //通过异常捕获的方法验证
        try{
            for (int i = 0; i < verifiedData.length; i++) {
                Integer.parseInt(verifiedData[i].trim());
            }
            return true;
        }catch(NumberFormatException e) {
            return false;
        }
    }


    /**
     * 获取字符串数组中的数字
     * @param verifiedData 被验证的字符串数组
     * @return
     */
    public static String[] getStringArrayIsDigital(String[] verifiedData){

        //无数据返回false
        if (null == verifiedData || verifiedData.length < 1){
            return null;
        }

        //中间参数，用于最后转为返回数组
        List<String> middleList = new ArrayList<String>();

        //通过异常捕获的方法验证
        for (int i = 0; i < verifiedData.length; i++) {
            try{
                Integer.parseInt(verifiedData[i].trim());
                middleList.add(verifiedData[i].trim());
            }catch(NumberFormatException e) {

            }
        }

        return middleList.toArray(new String[middleList.size()]);
    }

    /**
     * 获取字符串以逗号分隔开中的数字
     * @param verifiedData 被验证的字符串
     * @return
     */
    public static String[] getStringArrayIsDigital(String verifiedData){

        if(!checkStringHaveData(verifiedData)){
            return null;
        }

        return getStringArrayIsDigital(verifiedData.split(","));
    }

    /**
     * 验证数据是否大于0
     * @param verifiedData 被验证的Integer
     * @return
     */
    public static boolean  checkIntMoreThanZero(Integer verifiedData){
        if (null != verifiedData && verifiedData > Constants.INT_ZERO){
            return true;
        }
        return false;
    }

    /**
     * 验证String能否转换为Long、Integer、Double、float
     * checkNum:在String需要转换的数据类型中选择一种
     * 1、Long；2、Integer；3、Double；4、Float
     */
    public static boolean checkStrTo(String str,Integer checkNum){
        try{
            if(checkStringHaveData(str) && null != checkNum && checkNum > Constants.INT_ZERO && checkNum < Constants.INT_FIVE ){
                if( 1 == checkNum ){
                    try{
                        Long.valueOf(str.trim());
                        return true;
                    }catch(Exception e){
                        return false;
                    }
                }else if( Constants.INT_TWO == checkNum ){
                    try{
                        Integer.valueOf(str.trim());
                        return true;
                    }catch(Exception e){
                        return false;
                    }
                }else if( Constants.INT_THREE == checkNum ){
                    try{
                        Double.valueOf(str.trim());
                        return true;
                    }catch(Exception e){
                        return false;
                    }
                }else if( Constants.INT_FOUR == checkNum ){
                    try{
                        Float.valueOf(str.trim());
                        return true;
                    }catch(Exception e){
                        return false;
                    }
                }else{
                    return false;
                }

            }else{
                return false;
            }
        }catch(Exception e){
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 获取String转换为Long、Integer、Double、float的值，错误则返回null
     * checkNum:在String需要转换的数据类型中选择一种
     * 1、Long；2、Integer；3、Double；4、Float
     */
    public static Object getStrTo(String str ,Integer getNum){
        try{
            if(checkStrNoNull(str) && null != getNum && getNum > Constants.INT_ZERO && getNum < Constants.INT_FIVE ){
                if( Constants.INT_ONE == getNum ){
                    try{
                        return Long.valueOf(str.trim());
                    }catch(Exception e){
                        return null;
                    }
                }else if( Constants.INT_TWO == getNum ){
                    try{
                        return Integer.valueOf(str.trim());
                    }catch(Exception e){
                        return null;
                    }
                }else if( Constants.INT_THREE == getNum ){
                    try{
                        return Double.valueOf(str.trim());
                    }catch(Exception e){
                        return null;
                    }
                }else if( Constants.INT_FOUR == getNum ){
                    try{
                        return Float.valueOf(str.trim());
                    }catch(Exception e){
                        return null;
                    }
                }else{
                    return null;
                }

            }else{
                return null;
            }
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取String转为Integer的值，错误则返回null
     *
     */
    public static Integer getStrToInteger(String str){
        return (Integer) getStrTo(str, 2);
    }

    /**
     * 获取String转为Integer的值，错误则返回0
     *
     */
    public static Integer getStrToIntNullZero(String str ,Integer returnInt){
        Integer middleInt = getStrToInteger(str);
        if (null == middleInt){
            middleInt = returnInt;
        }
        return middleInt;
    }

    /**
     * 验证时间的合法性
     * @param dateStr 需要验证的时间
     * @param beConverted 被验证的时间的格式
     */
    public static boolean checkDateStrToTime(String dateStr ,String beConverted){
        try{
            if(checkStrNoNull(dateStr)){
                SimpleDateFormat formatter = new SimpleDateFormat(beConverted);
                formatter.setLenient(false);
                formatter.format(formatter.parse(dateStr));
                return true;
            }
            return false;
        }catch(Exception e){
            System.out.println("时间错误！");
            return false;
        }
    }

    /**
     * 将时间strTime转为形如toConvert
     * @param strTime 要转换的时间
     * @param beConverted 被转换的时间的格式:包含时分秒则会读取原本的时分秒，否则为00:00:00
     * @param toConvert 需要转换的时间的格式
     * @param additionalTail 在转换后的时间String末尾添加的字符串
     * @return String
     * beConverted：默认为（即为null时）：yyyy-MM-dd HH:mm:ss
     * toConvert：默认为（即为null时）：yyyy-MM-dd HH:mm:ss
     */
    public static Timestamp getStrToTimestamp(String strTime , String beConverted , String toConvert , String additionalTail){
        try {
            if(!checkStrNoNull(strTime)){
                return null;
            }
            String str = getStrToDateStr(strTime, beConverted, toConvert,additionalTail);
            return Timestamp.valueOf(str);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将时间strDate转为形如toConvert
     * @param strDate 要转换的时间
     * @param beConverted 被转换的时间的格式:包含时分秒则会读取原本的时分秒，否则为00:00:00
     * @param toConvert 需要转换的时间的格式
     * @param additionalTail 在转换后的时间String末尾添加的字符串
     * @return String
     * beConverted：默认为（即为null时）：yyyy-MM-dd HH:mm:ss
     * toConvert：默认为（即为null时）：yyyy-MM-dd HH:mm:ss
     * 形如：
     * getStrToDateStr("2016-05-31 16:13:45.5", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm:ss",null) ：24小时制
     * getStrToDateStr("2016-05-31 16:13:45.5", "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss",null) ：24小时制--》2016-05-31 00:00:00
     * getStrToDateStr("2016-05-31 16:13:45", "yyyy-MM-dd hh:mm:ss", "yyyy-MM-dd hh:mm:ss",null) ：12小时制
     * getStrToDateStr("05-31-2016 16:13:45", "MM-dd-yyyy HH:mm:ss" , "yyyy-MM-dd" ,null )：结果为：2016-05-31
     * getStrToDateStr("05-31-2016 16:13:45", "MM-dd-yyyy" , "yyyy-MM-dd" ," 23:59:59" )：结果为：2016-05-31
     * getStrToDateStr("05-31-2016 16:13:45", "MM-dd-yyyy" , "yyyy-MM-dd"  ," 23:59:59"):结果为：2016-05-31 23:59:59
     */
    public static String getStrToDateStr(String strDate ,String beConverted ,String toConvert ,String additionalTail){
        if(!checkStrNoNull(strDate)){
            return null;
        }
        try{
            boolean bl = false;
            if(strDate.trim().startsWith(Constants.SHORT_TERM)){
                strDate = strDate.trim().substring(1);
                bl = true;
            }
            SimpleDateFormat simpleDateFormat = null;
            if(!checkStrNoNull(beConverted)){
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            }else{
                simpleDateFormat = new SimpleDateFormat(beConverted);
            }

            Date date = simpleDateFormat.parse(strDate);

            if(!checkStrNoNull(toConvert)){
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            }else{
                simpleDateFormat = new SimpleDateFormat(toConvert);
            }

            String formattedTime = simpleDateFormat.format(date);

            formattedTime = formattedTime.trim() + getStrTrim(additionalTail);
            if(bl){
                if(formattedTime.trim().startsWith(Constants.SHORT_TERM)){
                    return formattedTime;
                }else{
                    return "-" + formattedTime;
                }
            }else{
                return formattedTime;
            }

        }catch(Exception e){
            System.out.println("时间转换异常");
            return null;
        }
    }

    /**
     * String不为空则去掉两边空格，为空则返回“”
     * @param str
     * @return
     */
    public static String getStrTrim(String str){
        if(checkStrNoNull(str)){
            return str.trim();
        }else{
            return "";
        }
    }

    /**
     * 判断路径filePath下的 文件/文件夹 是否存在，不存在创建，并返回File
     * @param filePath:文件路径
     * @param bl：最底层是否是文件而非文件夹，默认为true
     * @return
     * note:格式不可改变分隔用“/”
     * eg:checkFile("E:/root/20161009/icitem012.dbf",null,)
     */
    public static File getFile(String filePath ,boolean bl){
        try {
            File file = null;
            if(null != filePath && !"".equals(filePath.trim())){
                if(!bl){//文件夹
                    file = getFolderCreateFolder(filePath);
                }else{//文件
                    file = getFileCreateFile(filePath);
                }
            }
            return file;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断文件是否存在，存在时返回File,不存在时创建并返回File;不存在时创建文件夹
     * @return File
     */
    public static File getFileCreateFile(String filePath){
        try {
            try {
                if(!checkStrNoNull(filePath)){
                    return null;
                }

                String[] strArry = filePath.trim().split("/");
                String fileName = strArry[strArry.length-1];
                String foldName = filePath.trim().replaceAll(fileName, "");

                File file = new File(foldName);
                if(!file.exists()){
                    file.mkdirs();
                }

                file = new File(foldName,fileName);
                if(!file.exists()){
                    file.createNewFile();
                }
                return file;
            } catch (Exception e) {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断文件夹是否存在，存在返回File ，不存在则创建File并返回
     * @return
     */
    public static File getFolderCreateFolder(String filePath){
        try {
            if(!checkStrNoNull(filePath)){
                return null;
            }

            File file = new File(filePath);
            if(!file.exists()){
                file.mkdirs();
            }
            return file;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 拷贝文件
     *
     * @param in
     *            源文件，包括整个文件实体
     * @param out
     *            目的文件，该文件对象只有文件路径与文件名
     *
     * @throws IOException
     *             如果发生输入输出错误，如无源文件、路径错误等
     */
    public static void copyFile(String in, String out) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(new File(in));

            // 判断文件夹是否存在
            String filePath = getFilePath(out);
            File uploadPath = new File(filePath);
            if (!uploadPath.exists()) {
                uploadPath.mkdir();
            }

            fos = new FileOutputStream(out);

            int r = 0;
            byte[] buf = new byte[1024];
            while ((r = fis.read(buf)) != -1) {
                fos.write(buf, 0, r);
            }
        } catch (IOException e) {
            throw e;
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                throw e;
            }
        }
    }

    /**
     * 获得文件路径
     *
     * @param path 文件绝对路径 + 文件名
     *
     * @return String 文件绝对路径
     *
     */
    public static String getFilePath(String path) throws IOException {
        File directory = new File(path);
        return directory.getParent();
    }

}
